\begin{itemize}
	\item{\textbf{Acci\'on:}}
	El objetivo de la funci\'on es combinar 2 im\'agenes (A y B) de igual tama\~no generando una tercer imagen. Cada pixel de la imagen resultante se forma de la siguiente manera:
	\begin{displaymath}
	I_{dst}(i,j) \ = \frac{alpha.(I_{srcA}(i,j) - I_{srcB}(i,j))}{255,0}+I_{srcB}(i,j)\\
	\end{displaymath}
	donde $alpha$ $\in$ [0,0 ; 255,0].	
	\item{\textbf{Prototipo:}}
	void $combinar$ (unsigned char* src$_{a}$, unsigned char* dst$_{b}$, unsigned char* $dst$, int $h$, int $w$, int $row\_size$, float $alpha$)
	\item{\textbf{Procedimiento en C:}}
	Recorremos todas las columnas y por cada columna todas las filas de a 1 pixel por iteraci\'on en ambas im\'agenes de entrada. 
	Tenemos los 2 pixeles de cada imagen A y B y aplicamos la f\'ormula dado que tenemos los datos. El resultado lo copiamos en una tercer imagen en la misma fila y columna que est\'abamos recorriendo las im\'agenes de entrada.
	Este algoritmo no trabaja en paralelo dado que en cada iteraci\'on se trabaja con 1 pixel de cada imagen y se escribe 1 pixel en la imagen destino.
	\item{\textbf{Procedimiento en ASM:}}
	Por la convenci\'on $C$ el valor de $alpha$ se encuentra en el registro $xmm0$. 
	Lo primero que hacemos antes de recorremos las filas y columnas de las im\'agenes es poner en el registro $xmm7$ los 4 valores float: 255, que lo ten\'iamos guardado en una variable $divisor$.
	Tambi\'en ubicamos 4 valores float de $alpha$ en el registro $xmm0$.
	Una vez hecho esto, empezamos a recorrer las filas y por cada filas las columnas de las 2 im\'agenes de entrada. 
	Trabajamos copiando 16 bytes de cada imagen de entrada a los registros $xmm1$ y $xmm2$.
	El primer c\'alculo en la f\'ormula es la resta entre los dos pixeles. si seguimos manteniendo cada pixel en byte podr\'ia suceder que la resta no entrase en 8 bits por lo caul pasamos cada byte a word mediante la instrucci\'on $pmovzxbw$.
	Hacemos una copia sobre $xmm11$ y $xmm12$ de los registros que tienen los words de la imagen B para luego sumarlos al final de la f\'ormula.
	Realizamos la resta entre cada pixel de tama\~no 1 word mediante $psubsw$.
	Nos quedan los registros $xmm1$ y $xmm3$ con el resultado de la resta de los 16 pixeles de tama\~no un word cada uno.
	Luego debemos multiplicar cada pixel por $alpha$. Al ser $alpha$ floar debemos pasar los pixeles a float, para ello pasamos cada word a doubleWord con $pmovsxwd$.
	Al pasarlos tenemos los valores en 4 $xmm$, donde cada registro tiene 4 pixel de tama\~no float.
	Con $cvtdq2ps$ convertimos los 4 $DW$ de cada $xmm$ a float.
	Luego multiplicamos ($mulps$) cada registro ($xmm1$, $xmm2$, $xmm3$ y $xmm4$) con $xmm0$ que ten\'iamos guardado 4 $alpha$.
	Nos falta dividir cada registro ($divps$) por el registro $xmm7$ que tiene 4 float con valor 255,0.
	A partir de ahora en m\'as s\'olo nos queda la suma, por lo cual no hace falta seguir trabajando en float. Convertimos los 4 registros $xmm$ a enteros con $cvtps2dq$, quedando en cada registro 4 entreros de tama\~no $DW$.
	Pasamos cada $DW$ a word usando la instrucci\'on $packssdw$ que pasa de $DW$ a $word$ manteniendo el signo porque la resta pudo haber dado un n\'umero negativo.
	Se empaquetan dos registros, $xmm1$ con $xmm2$ y $xmm3$ con $xmm4$. Donde los primeros 8 bytes de $xmm1$ resultan ser los 8 word que antes ten\'ia y los segundo 8 bytes los 8 words que ten\'ia $xmm2$.
	Se tenien en $xmm1$ y en $xmm3$ 16 words que corresponden a los 16 pixeles trabajados. Nos queda sumar a cada registro los pixeles de la imagen B. Pero eso lo hab\'iamos guardado en $xmm11$ y $xmm12$ y ya los tenemos en words.
	Hacemos la suma entre $xmm1$+$xmm11$ y $xmm3$+$xmm12$.
	Para copiar a la imagen de salida debemos pasar cada pixel a byte. Eso los hacemos con la siguiente instrucci\'on: $packuswb$ xmm1, xmm3. Empaquetamos en la parte baja los 8 word que estaban en $xmm1$ y en la parte alta los 8 words que estaban en $xmm3$.
	Finalmente, nos queda en $xmm1$ los 16 pixeles con tama\~no 1 byte cada uno y son el resultado de haberles aplicado el filtro correspondiente.
	Copiamos el registro $xmm1$ a la imagen de salida y avanzamos hacia las siguientes 16 columnas. Si nos quedan mas o 16 columnas por recorrer seguimos nuevamente recorriendo por columnas. En caso contrario (nos quedan menos de 16 columnas por recorrer), retrocedemos tantas columnas como fuese necesario para agarrar exactamente 16 columnas. Si bien al realizar esto pueden existir pixeles que se pisen nos parece lo mejor para poder seguir trabajando en paralelo.
	Una vez recorridas todas las columnas de una fila avanzamos hacia la siguiente fila.
	Este algoritmo trabaja en paralelo dado que en cada iteraci\'on nos traemos 16 pixeles de cada imagen de entrada y pegamos 16 pixeles a la imagen de salida.
	\end{itemize}
